// import md5 from "./md5.js"
// import { Base64 } from './base64.js';

const baseUrl = 'https://www.broadcast-agr.com/api'; //正式
//const baseUrl = 'http://192.168.3.29:8080/nongda_war/api'; //测试

const request = (type = 'GET', url = '', data = {}) => {
	//传给后台请求头
	let time = parseInt(new Date().getTime() / 1000);//时间戳 方法二：Date.parse(new Date())/1000;
	//let msign = md5('appid=326794513&appsecret=W8aI6KohDHM871I5ERG5Et&timestamp=${time}')
	// token加密算法
	// let token = {
	// 	token: uni.getStorageSync('ywy_token') || 0,
	// 	sign: msign,
	// 	timestamp: time,
	// }
	return new Promise((resolve, reject) => {
		uni.request({
			method: type,
			url: url!=''? baseUrl +'/service'+ url: baseUrl +'/service'+'?json='+JSON.stringify(data),
			data: data || {},
			header: {
				'content-type': 'application/json',
				// 'token': Base64.encode(JSON.stringify(token)),
				// 'appname': 'lySalesman',
				// 'version': '20210601',
			},
			dataType: 'json',
			success: res => {
				if (res.data.code == '1001') {
					uni.clearStorageSync('token');
					// #ifdef APP-PLUS || H5
					uni.reLaunch({url: '/pages/login/login'});
					// #endif
				}else {
					resolve(res);
				}
			},
			fail: err => {
				reject(err);
			}
		});
	});
}

// 封装get方法
function get(obj) {
	return request('GET', obj.url, obj.data)
}
// 封装post方法
function post(obj) {
	return request('POST', obj.url, obj.data)
}
// 封装put方法
function put(obj) {
	return request('PUT', obj.url, obj.data)
}

export default { post, get }

//第二步：在main.js文件全局引入
//import http from "./common/js/http.js"
// Vue.prototype.$http = http;

//第三步：应用
// this.$http.get({
// 	url: '/login/login',
// 	data:{
// 		data1: '1',
// 		data2: '2'
// 	}
// }).then(res => {
// 	console.log(res)
// })


/* 
const baseUrl = 'http://127.0.0.1:8080/api/'

const showToast = (title) => {
    uni.showToast({
        title: title,
        icon: 'none'
    })
}

 // * @method http
 // * @param {String} url 接口地址
 // * @param {Object} obj 接口配置和参数
 // * @return {Object} requestTask
const http = (url, obj) => {
    let option = obj.option || {}
    let hideLoading = option.hideLoading || false // 是否显示 loading
    let hideMsg = option.hideMsg || false // 是否隐藏错误提示
    let data = obj.data || {} // 请求数据
    let token = '' // 登录鉴权获得的 token
    uni.getStorage({
        key: 'token',
        success: (ress) => {
            token = ress.data
        }
    })
    if (!hideLoading) {
        uni.showLoading({
            title: '加载中...',
            mask: true
        })
    }
    return uni.request({
        url: baseUrl + url,
        method: option.method || 'POST', // 默认 post 请求
        header: {
            'Token': token
        },
        data: data,
        success: res => { // 服务器成功返回的回调函数
            if (!hideLoading) uni.hideLoading()
            if (res.statusCode === 200) {
                let result = res.data
                if (result.errcode === '0') {
                    if (obj.success) obj.success(result)
                    return
                }
                if (obj.fail) obj.fail(result.errmsg)
                if (!hideMsg) showToast(result.errmsg)
            } else { // 返回值非 200，强制显示提示信息
                showToast('[' + res.statusCode + '] 系统处理失败')
                if (obj.fail) obj.fail('[' + res.statusCode + '] 系统处理失败')
            }
        },
        fail: (err) => { // 接口调用失败的回调函数
            if (!hideLoading) uni.hideLoading()
            if (err.errMsg != 'request:fail abort') {
                showToast('连接超时，请检查您的网络。')
                if (obj.fail) obj.fail('连接超时，请检查您的网络。')
            }
        }
    })
}
export default http

/* 带有加载处理的http.js
导入和使用 http.js
在需要请求接口的地方导入 http.js。

import http from '@/commons/http.js'
具体使用方式如下：

const requestTask = http('data/get', {
    data: {
        id: id
    },
    option: {
        hideLoading: false, // 默认 false
        hideMsg: true, // 默认 false
        method: 'POST' // 默认 POST
    },
    success: res => {
        console.log(res.data)
    },
    fail: err => {
        console.log(err)
    }
})

// 如果需要的话，可以通过改方法中断请求任务
requestTask.abort()
const requestTask = http('data/get', {
    data: {
        id: id
    },
    option: {
        hideLoading: false, // 默认 false
        hideMsg: true, // 默认 false
        method: 'POST' // 默认 POST
    },
    success: res => {
        console.log(res.data)
    },
    fail: err => {
        console.log(err)
    }
})

// 如果需要的话，可以通过改方法中断请求任务
requestTask.abort()
******************************************/
/*
//说明：目前已发布到uniapp插件市场
const baseUrl = "http://api.liy.cn"

//网络判断
const hasNetwork = function(){
    var result = true;
    uni.getNetworkType({
        success: function (res) {
            console.log("网络类型:" + res.networkType);
            if(res.networkType == "none"){
                uni.showToast({
                    title:"网络未连接",
                    icon:'none'
                });
                result = false;
            }
        }
    });
    return result;
}

//登录请求
const sendLoginRequest = function(param){
    //为什么程序未执行网络变化的监听：网络发生变化才会触发
    // uni.onNetworkStatusChange(function(res){
    //  // console.log("网络类型:" + res.networkType + ",网络连接:" + res.isConnected);
    //  if(!res.isConnected){
    //      uni.showToast({
    //          title:"网络未连接",
    //          icon:'none'
    //      });
    //      return;
    //  }
    // })
    
    // if(!hasNetwork()){//移到页面中判断：适配按钮状态变化的逻辑
    //  return;
    // }

    var _self = this, data = param.data || {}, siteBaseUrl = baseUrl + "/";
    uni.request({
        url: siteBaseUrl + "user/login",
        method: 'POST',
        //header: {'content-type' : "application/json"},//默认
        header: {'content-type' : "application/x-www-form-urlencoded"},
        data: data,
        success:function(res){
            console.log("网络请求success:" + JSON.stringify(res));
            if (res.statusCode && res.statusCode != 200) {//api错误(Error StatusCode)
                uni.showToast({
                    title:"api错误",
                    icon:'none'
                });
                
                return;
            }
            if (res.data.code) {
                if (res.data.code != "0") {//Error ResultCode
                    uni.showToast({
                        title:res.data.msg,
                        icon:'none'
                    });
                    
                    return;
                }
            } else {//No ResultCode
                uni.showToast({
                    title:"无结果码",
                    icon:'none'
                });
                
                return;
            }
            typeof param.success == "function" && param.success(res.data);
        },
        fail:function(e){
            console.log("网络请求fail:" + JSON.stringify(e));
            uni.showToast({
                title:"请检查网络",
                icon:'none'
            });
            
            typeof param.fail == "function" && param.fail(e.data);
        },
        complete:function(){
            console.log("网络请求complete");
            typeof param.complete == "function" && param.complete();
            return;
        }
    });
}

//封装除登录外的业务网络请求
const sendRequest = function(param){
    if(!hasNetwork()){//移到页面中判断：适配按钮状态变化的逻辑
        return;
    }
    var _self = this, 
        url = param.url,
        method = param.method,
        header = {},
        data = param.data || {}, 
        token = "",
        hideLoading = param.hideLoading || true;
        
    //拼接完整请求地址
    var requestUrl = baseUrl + "/" + url;
    //固定参数:仅仅在小程序绑定页面通过code获取token的接口默认传递了参数token = login
    if(!data.token){//其他业务接口传递过来的参数中无token
        token = uni.getStorageSync(this.sessionKey);//参数中无token时在本地缓存中获取
        console.log("当前token:" + token);
        if(!token){//本地无token需重新登录(退出时清缓存token)
            uni.redirectTo({url:'/pages/login/login'});
            return;
        }else{
            data.token = token;
        }
    }
    var timestamp = Date.parse(new Date());//时间戳
    data["timestamp"] = timestamp;
    var center_id = _self.getUserInfo().center_id || "";
    data["center_id"] = center_id;
    
    //请求方式:GET或POST(POST需配置header: {'content-type' : "application/x-www-form-urlencoded"},)
    if(method){
        method = method.toUpperCase();//小写改为大写
        if(method=="POST"){
            header = {'content-type' : "application/x-www-form-urlencoded"};
        }else{
            header = {'content-type' : "application/json"};
        }
    }else{
        method = "GET";
        header = {'content-type' : "application/json"};
    }
    //用户交互:加载圈
    if (!hideLoading) {
        uni.showLoading({title:'加载中...'});
    }
    
    console.log("网络请求start：url:" + requestUrl + "，params:" +JSON.stringify(data));
    //网络请求
    uni.request({
        url: requestUrl,
        method: method,
        header: header,
        data: data,
        success: res => {
            console.log("网络请求success:" + JSON.stringify(res));
            if (res.statusCode && res.statusCode != 200) {//api错误
                uni.showToast({
                    title:"api错误",
                    icon:'none'
                });
                return;
            }
            if (res.data.code) {//返回结果码code判断:0成功,1错误,-1未登录(未绑定/失效/被解绑)
                if (res.data.code == "-1") {
                    uni.redirectTo({url:'/pages/login2/login2'});
                    return;
                }
                if (res.data.code != "0") {//code为1失败，code为0成功
                    uni.showToast({
                        title: res.data.msg,
                        icon:'none'
                    });
                    return;
                }
            } else{
                uni.showToast({
                    title:"无结果码",
                    icon:'none'
                });
                return;
            }
            typeof param.success == "function" && param.success(res.data);
        },
        fail: (e) => {
            console.log("网络请求fail:" + JSON.stringify(e));
            uni.showToast({
                title:"请检查网络",
                icon:'none'
            });
            
            typeof param.fail == "function" && param.fail(e.data);
        },
        complete: () => {
            console.log("网络请求complete");
            if (!hideLoading) {
                uni.hideLoading();
            }
            typeof param.complete == "function" && param.complete();
            return;
        }
    });
}

//上传文件
const uploadFileRequest = function(param) {
    if(!hasNetwork()){//移到页面中判断：适配按钮状态变化的逻辑
        return;
    }
    var _self = this, 
        url = param.url || "",
        path = param.path || "",
        name = param.name || "file",
        data = param.data || {},
        token = "";
        
    if(url == ""){
        url =  _self.getUploadFileUrl();//默认的上传文件地址
    }else{
        url = baseUrl + "/" + url;
    }
    
    if(!data.token){
        token = uni.getStorageSync(this.sessionKey);
        console.log("当前token:" + token);
        if(!token){
            uni.redirectTo({url:'/pages/login2/login2'});
            return;
        }else{
            data.token = token;
        }
    }
    var timestamp = Date.parse(new Date());//时间戳
    data["timestamp"] = timestamp;
    
    console.log("网络请求start：url:" + url + "，params:" +JSON.stringify(data));
    uni.uploadFile({ 
        url: url, 
        filePath: path,
        name: name,
        formData: data,
        success: (res) => {
            console.log("网络请求success-res:" + JSON.stringify(res));//json对象转json字符串
            console.log("网络请求success-statusCode:" + res.statusCode);
            console.log("uniapp上传文件api返回的data是字符串类型:" + res.data);
            if (res.statusCode && res.statusCode != 200) {//api错误(Error StatusCode)
                uni.showToast({
                    title:"api错误",
                    icon:'none'
                });
                
                return;
            }
            var dataString = res.data;//json字符串
            var res = JSON.parse(dataString);//json字符串转json对象
            if (res.code) {
                if (res.code != "0") {//Error ResultCode
                    uni.showToast({
                        title:res.msg,
                        icon:'none'
                    });
                    
                    return;
                }
            } else {//No ResultCode
                uni.showToast({
                    title:"无结果码",
                    icon:'none'
                });
                
                return;
            }
            typeof param.success == "function" && param.success(res);
        },
        fail: (e) => {
            console.log("网络请求fail");
            uni.showToast({
                title:"请检查网络",
                icon:'none'
            });
            typeof param.fail == "function" && param.fail(e.data);
        },
        complete: () => {
            console.log("网络请求complete");
            typeof param.complete == "function" && param.complete();
            return;
        }
    });
}

export default {
    sendLoginRequest,
    sendRequest,
    uploadFileRequest
}

// 单页面引入js文件并调用
// <script>
// import Http from '../../common/http.js'
// var _self;
// export default {
//     data() {
//         return {
//             logining: false
//         }
//     },
//     methods: {
//         login:function(){
//             _self = this;
//             if(!this.Http.hasNetwork()){
//                 return;
//             }
//             _self.logining = true;//按钮不可用
//             Http.sendLoginRequest({
//                 data: {
//                     mobile : "15639150623",
//                     password : "aaaaaa"
//                 },
//                 success:function(res){
//                     uni.switchTab({
//                         url:'../tabBar/home/home'
//                     })
//                 },
//                 fail:function(e){},
//                 complete:function(){
//                     _self.logining = false;//按钮可用
//                 }
//             })
//         }
//     }
// }
// </script>



// 全局引入js文件并调用
// import Vue from 'vue'
// import App from './App'

// import Http from './common/http.js'

// Vue.config.productionTip = false
// Vue.prototype.Http = Http


// App.mpType = 'app'

// const app = new Vue({
//     Http,
//     ...App
// })
// app.$mount()


// <script>
// // import Http from '../../common/http.js'
// var _self;
// export default {
//     data() {
//         return {
//             logining: false
//         }
//     },
//     methods: {
//         login:function(){
//             _self = this;
//             if(!this.Http.hasNetwork()){
//                 return;
//             }
//             _self.logining = true;//按钮不可用
//             this.Http.sendLoginRequest({
//                 data: {
//                     mobile : "15639150623",
//                     password : "aaaaaa"
//                 },
//                 success:function(res){
//                     uni.switchTab({
//                         url:'../tabBar/home/home'
//                     })
//                 },
//                 fail:function(e){},
//                 complete:function(){
//                     _self.logining = false;//按钮可用
//                 }
//             })
//         }
//     }
// }
// </script>
***************************************************************/
/*网络请求设置拦截器-可以总的处理请求前和请求后的事情
import http from './interface'
 
 // * 将业务所有接口统一起来便于维护
 // * 如果项目很大可以将 url 独立成文件，接口分成不同的模块
 // * 

 
// 单独导出(测试接口) import {test} from '@/common/vmeitime-http/'
export const test = (data) => {
	//设置请求前拦截器
	http.interceptor.request = (config) => {
		config.header = {
			"token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
		}
	}
	//设置请求结束后拦截器
	http.interceptor.response = (response) => {
		console.log('个性化response....')
		//判断返回状态 执行相应操作
		return response;
	}
    return http.request({
		baseUrl: 'https://unidemo.dcloud.net.cn/',
        url: 'ajax/echo/text?name=uni-app',
		dataType: 'text',
        data,
    })
}
 
// 轮播图
export const banner = (data) => {
    return http.request({
        url: '/banner/36kr',
        method: 'GET', 
        data,
		// handle:true
    })
}
 
// 默认全部导出  import api from '@/common/vmeitime-http/'
export default {
	test,
    banner
}


//====interface.js
export default {
	config: {
		baseUrl: "https:",
		header: {
			'Content-Type':'application/json;charset=UTF-8',
			'Content-Type':'application/x-www-form-urlencoded'
		},  
		data: {},
		method: "GET",
		dataType: "json",  // 如设为json，会对返回的数据做一次 JSON.parse 
		responseType: "text",
		success() {},
		fail() {},
		complete() {}
	},
	interceptor: {
		request: null,
		response: null
	},
	request(options) {
		if (!options) {
			options = {}
		}
		options.baseUrl = options.baseUrl || this.config.baseUrl
		options.dataType = options.dataType || this.config.dataType
		options.url = options.baseUrl + options.url
		options.data = options.data || {}
		options.method = options.method || this.config.method
		//TODO 加密数据
		
		//TODO 数据签名
		// _token = {'token': getStorage(STOREKEY_LOGIN).token || 'undefined'},
		// _sign = {'sign': sign(JSON.stringify(options.data))}
		// options.header = Object.assign({}, options.header, _token,_sign) 
	   
		return new Promise((resolve, reject) => {
			let _config = null
			
			options.complete = (response) => {
				let statusCode = response.statusCode
				response.config = _config
				if (process.env.NODE_ENV === 'development') {
					if (statusCode === 200) {
						console.log("【" + _config.requestId + "】 结果：" + JSON.stringify(response.data))
					}
				}
				if (this.interceptor.response) {
					let newResponse = this.interceptor.response(response)
					if (newResponse) {
						response = newResponse
					}
				}
				// 统一的响应日志记录
				_reslog(response)
				if (statusCode === 200) { //成功
					resolve(response);
				} else {
					reject(response)
				}
			}
 
			_config = Object.assign({}, this.config, options)
			_config.requestId = new Date().getTime()
 
			if (this.interceptor.request) {
				this.interceptor.request(_config)
			}
			
			// 统一的请求日志记录
			_reqlog(_config)
 
			if (process.env.NODE_ENV === 'development') {
				console.log("【" + _config.requestId + "】 地址：" + _config.url)
				if (_config.data) {
					console.log("【" + _config.requestId + "】 参数：" + JSON.stringify(_config.data))
				}
			}
 
			uni.request(_config);
		});
	},
	get(url, data, options) {
		if (!options) {
			options = {}
		}
		options.url = url
		options.data = data
		options.method = 'GET'  
		return this.request(options)
	},
	post(url, data, options) {
		if (!options) {
			options = {}
		}
		options.url = url
		options.data = data
		options.method = 'POST'
		return this.request(options)
	},
	put(url, data, options) {
		if (!options) {
			options = {}
		}
		options.url = url
		options.data = data
		options.method = 'PUT'
		return this.request(options)
	},
	delete(url, data, options) {
		if (!options) {
			options = {}
		}
		options.url = url
		options.data = data
		options.method = 'DELETE'
		return this.request(options)
	}
}
*/